home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / r2l.lha / r2l / src / r2l.rex < prev    next >
OS/2 REXX Batch file  |  1992-08-18  |  9KB  |  336 lines
  1. /* $Id: rex.rex,v 3.2 1991/11/21 14:42:27 grosch Exp grosch $ */
  2.  
  3. /* $Log: rex.rex,v $
  4.  * Revision 3.2  1991/11/21  14:42:27  grosch
  5.  * fixed bug: interference of right context between constant and non-constant RE
  6.  * new version of RCS on SPARC
  7.  *
  8.  * Revision 3.1  91/06/06  15:29:42  grosch
  9.  * fixed bug in EOF secton: yyStart (STD);
  10.  * 
  11.  * Revision 3.0  91/04/04  18:08:10  grosch
  12.  * introduced partitioning of character set
  13.  * 
  14.  * Revision 2.0  91/03/08  18:18:14  grosch
  15.  * turned tables into initialized arrays (in C)
  16.  * reduced case size
  17.  * changed interface for source position
  18.  * 
  19.  * Revision 1.4  90/08/22  17:33:38  grosch
  20.  * fixed bug with backslash in comments
  21.  * 
  22.  * Revision 1.3  90/05/17  11:17:47  grosch
  23.  * allow RULE or RULES
  24.  * 
  25.  * Revision 1.2  89/02/23  15:56:12  grosch
  26.  * added DEFAULT section
  27.  * 
  28.  * Revision 1.1  89/01/17  15:01:58  grosch
  29.  * correction and redesign of source position handling
  30.  * 
  31.  * Revision 1.0  88/10/04  11:59:58  grosch
  32.  * Initial revision
  33.  * 
  34.  */
  35.  
  36. /* Ich, Doktor Josef Grosch, Informatiker, Nov. 1987 */
  37.  
  38. EXPORT    {
  39.  
  40. FROM Idents    IMPORT tIdent    ;
  41. FROM StringMem    IMPORT tStringRef;
  42. FROM Texts    IMPORT tText    ;
  43. FROM Positions    IMPORT tPosition;
  44.  
  45. TYPE
  46.    tScanAttribute    = RECORD
  47.           Position    : tPosition    ;
  48.      CASE : INTEGER OF
  49.      | 1: Ident    : tIdent    ;
  50.      | 2: Number    : SHORTCARD    ;
  51.      | 3: String    : tStringRef    ;
  52.      | 4: Ch    : CHAR        ;
  53.      | 5: Text    : tText        ;
  54.      END;
  55.       END;
  56.  
  57. PROCEDURE ErrorAttribute (Token: CARDINAL; VAR Attribute: tScanAttribute);
  58. }
  59.  
  60. GLOBAL    {
  61.  
  62. FROM SYSTEM    IMPORT ADDRESS;
  63. FROM Strings    IMPORT tString, Concatenate, Char, SubString,
  64.             StringToInt, AssignEmpty, Length;
  65. FROM Texts    IMPORT MakeText, Append;
  66. FROM StringMem    IMPORT tStringRef, PutString;
  67. FROM Idents    IMPORT tIdent, MakeIdent, NoIdent;
  68. FROM Errors    IMPORT ErrorMessage;
  69. FROM Positions    IMPORT tPosition;
  70.  
  71. CONST
  72.    SymIdent        = 1    ;
  73.    SymNumber        = 2    ;
  74.    SymString        = 3    ;
  75.    SymChar        = 4    ;
  76.    SymTargetcode    = 5    ;
  77.    SymExport        = 32    ;
  78.    SymGlobal        = 6    ;
  79.    SymLocal        = 31    ;
  80.    SymBegin        = 7    ;
  81.    SymClose        = 8    ;
  82.    SymEof        = 34    ;
  83.    SymDefault        = 36    ;
  84.    SymDefine        = 9    ;
  85.    SymStart        = 10    ;
  86.    SymRules        = 11    ;
  87.    SymNot        = 30    ;
  88.    SymDot        = 12    ;
  89.    SymComma        = 13    ;
  90.    SymEqual        = 14    ;
  91.    SymColon        = 15    ;
  92.    SymColonMinus    = 35    ;
  93.    SymNrSign        = 33    ;
  94.    SymSlash        = 16    ;
  95.    SymBar        = 17    ;
  96.    SymPlus        = 18    ;
  97.    SymMinus        = 19    ;
  98.    SymAsterisk        = 20    ;
  99.    SymQuestion        = 21    ;
  100.    SymLParen        = 22    ;
  101.    SymRParen        = 23    ;
  102.    SymLBracket        = 24    ;
  103.    SymRBracket        = 25    ;
  104.    SymLBrace        = 26    ;
  105.    SymRBrace        = 27    ;
  106.    SymLess        = 28    ;
  107.    SymGreater        = 29    ;
  108.  
  109.    BraceMissing        = 13    ;
  110.    UnclosedComment    = 14    ;
  111.    UnclosedString    = 16    ;
  112.    Error        = 3    ;
  113.  
  114. VAR
  115.    level    : INTEGER    ;
  116.    string    : tString    ;
  117.    NoString    : tStringRef    ;
  118.    Position    : tPosition    ;
  119.  
  120. PROCEDURE ErrorAttribute (Token: CARDINAL; VAR Attribute: tScanAttribute);
  121.    BEGIN
  122.       CASE Token OF
  123.       |  SymIdent    : Attribute.Ident  := NoIdent;
  124.       |  SymNumber    : Attribute.Number := 0;
  125.       |  SymString    : Attribute.String := NoString;
  126.       |  SymChar    : Attribute.Ch       := '?';
  127.       |  SymTargetcode    : MakeText (Attribute.Text);
  128.       ELSE
  129.       END;
  130.    END ErrorAttribute;
  131. }
  132.  
  133. LOCAL    { VAR TargetCode, String, Word: tString; PrevState: SHORTCARD; }
  134.  
  135. BEGIN    {
  136.    level := 0;
  137.    AssignEmpty (string);
  138.    NoString := PutString (string);
  139. }
  140.  
  141. EOF    {
  142.    CASE yyStartState OF
  143.    | targetcode    ,
  144.      set    : ErrorMessage (BraceMissing    , Error, Attribute.Position);
  145.    | comment    : ErrorMessage (UnclosedComment    , Error, Attribute.Position);
  146.    | CStr1, CStr2,
  147.      Str1, Str2    : ErrorMessage (UnclosedString    , Error, Attribute.Position);
  148.    ELSE
  149.    END;
  150.    yyStart (STD);
  151. }
  152.  
  153. DEFINE
  154.    letter    = {A-Z a-z}    .
  155.    digit    = {0-9}        .
  156.    string    = - {"\n}    .
  157.    cmtch    = - {*\t\n}    .
  158.    code        = - {{\}\t\n\\'"} .
  159.    StrCh1    = - {'\t\n}    .
  160.    StrCh2    = - {"\t\n}    .
  161.    CStrCh1    = - {'\t\n\\}    .
  162.    CStrCh2    = - {"\t\n\\}    .
  163.  
  164. START targetcode, set, rules, comment, Str1, Str2, CStr1, CStr2
  165.  
  166. RULES
  167.  
  168. #targetcode#    "{"    : {
  169.                IF level = 0 THEN
  170.                   MakeText (Attribute.Text);
  171.                   AssignEmpty (TargetCode);
  172.                   Position := Attribute.Position;
  173.                ELSE
  174.                   GetWord (Word);
  175.                   Concatenate (TargetCode, Word);
  176.                END;
  177.                INC (level);
  178.             }
  179.  
  180. #targetcode#    "}"    :- {
  181.                DEC (level);
  182.                IF level = 0 THEN
  183.                   yyStart (PrevState);
  184.                   Append (Attribute.Text, TargetCode);
  185.                   Attribute.Position := Position;
  186.                   RETURN SymTargetcode;
  187.                ELSE
  188.                   GetWord (Word);
  189.                   Concatenate (TargetCode, Word);
  190.                END;
  191.             }
  192.  
  193. #targetcode#    code +    :- {
  194.                IF level > 0 THEN
  195.                   GetWord (Word);
  196.                   Concatenate (TargetCode, Word);
  197.                END;
  198.             }
  199.  
  200. #targetcode#    \t    :- {
  201.                IF level > 0 THEN
  202.                   Strings.Append (TargetCode, 11C);
  203.                END;
  204.                yyTab;
  205.             }
  206.  
  207. #targetcode#    \n    :- {
  208.                IF level > 0 THEN
  209.                   Append (Attribute.Text, TargetCode);
  210.                   AssignEmpty (TargetCode);
  211.                END;
  212.                yyEol (0);
  213.             }
  214.  
  215. #targetcode#    \\ ANY    :- {
  216.                IF level > 0 THEN
  217.                   GetWord (Word);
  218.                   Strings.Append (TargetCode, Char (Word, 2));
  219.                END;
  220.             }
  221.  
  222. #targetcode#    \\    :- {
  223.                IF level > 0 THEN
  224.                   Strings.Append (TargetCode, '\');
  225.                END;
  226.             }
  227.  
  228. #targetcode#    '    : { GetWord (String); yyStart (CStr1); }
  229.  
  230. #targetcode#    \"    : { GetWord (String); yyStart (CStr2); }
  231.  
  232. #Str1#    StrCh1 +    ,
  233. #Str2#    StrCh2 +    ,
  234. #CStr1#    CStrCh1 + | \\ ANY ? ,
  235. #CStr2#    CStrCh2 + | \\ ANY ? :- {GetWord (Word); Concatenate (String, Word);}
  236.  
  237. #CStr1#    \\ \n        ,
  238. #CStr2#    \\ \n        :- {GetWord (Word); Concatenate (String, Word); yyEol (0);}
  239.  
  240. #Str1, CStr1# '        ,
  241. #Str2, CStr2# \"    :- {Strings.Append (String, Char (String, 1));
  242.                 yyPrevious; Concatenate (TargetCode, String);
  243.             }
  244.  
  245. #Str1, Str2, CStr1, CStr2# \t :- {Strings.Append (String, 11C); yyTab;}
  246.  
  247. #Str1, Str2, CStr1, CStr2# \n :- {ErrorMessage (UnclosedString, Error, Attribute.Position);
  248.                 Strings.Append (String, Char (String, 1));
  249.                 yyEol (0); yyPrevious; Concatenate (TargetCode, String);
  250.             }
  251.  
  252. #STD, rules#    "/*"    :- {yyStart (comment)    ;}
  253. #comment#    "*" | cmtch +    :- {}
  254. #comment#    "*/"    :- {yyPrevious        ;}
  255.  
  256. #STD#        EXPORT    : {PrevState := STD; yyStart (targetcode); RETURN SymExport    ;}
  257. #STD#        GLOBAL    : {PrevState := STD; yyStart (targetcode); RETURN SymGlobal    ;}
  258. #STD#        LOCAL    : {PrevState := STD; yyStart (targetcode); RETURN SymLocal    ;}
  259. #STD#        BEGIN    : {PrevState := STD; yyStart (targetcode); RETURN SymBegin    ;}
  260. #STD#        CLOSE    : {PrevState := STD; yyStart (targetcode); RETURN SymClose    ;}
  261. #STD#        DEFAULT    : {PrevState := STD; yyStart (targetcode); RETURN SymDefault    ;}
  262. #STD#        EOF    : {PrevState := STD; yyStart (targetcode); RETURN SymEof        ;}
  263. #STD#        DEFINE    : {RETURN SymDefine    ;}
  264. #STD#        START    : {RETURN SymStart    ;}
  265. #STD#        RULE S ?: {yyStart (rules);    RETURN SymRules        ;}
  266. #rules#        \NOT    : {RETURN SymNot    ;}
  267.  
  268. #STD, rules#    letter (letter | digit | _) * : {
  269.                GetWord (Word);
  270.                Attribute.Ident  := MakeIdent (Word);
  271.                RETURN SymIdent;
  272.             }
  273.  
  274. #STD, rules#    digit +    : {
  275.                GetWord (Word);
  276.                Attribute.Number := StringToInt (Word);
  277.                RETURN SymNumber;
  278.             }
  279.  
  280. #STD, rules#    \" string * \" : {
  281.                GetWord (Word);
  282.                SubString (Word, 2, Length (Word) - 1, TargetCode);
  283.                Attribute.String := PutString (TargetCode);
  284.                RETURN SymString;
  285.             }
  286.  
  287. #STD#        "."    : {RETURN SymDot    ;}
  288. #STD#        "="    : {RETURN SymEqual    ;}
  289. #STD, set#    "}"    : {yyPrevious;        RETURN SymRBrace    ;}
  290. #STD, set, rules# "-"    : {RETURN SymMinus    ;}
  291. #STD, rules#    ","    : {RETURN SymComma    ;}
  292. #STD, rules#    "|"    : {RETURN SymBar    ;}
  293. #STD, rules#    "+"    : {RETURN SymPlus    ;}
  294. #STD, rules#    "*"    : {RETURN SymAsterisk    ;}
  295. #STD, rules#    "?"    : {RETURN SymQuestion    ;}
  296. #STD, rules#    "("    : {RETURN SymLParen    ;}
  297. #STD, rules#    ")"    : {RETURN SymRParen    ;}
  298. #STD, rules#    "["    : {RETURN SymLBracket    ;}
  299. #STD, rules#    "]"    : {RETURN SymRBracket    ;}
  300. #STD, rules#    "{"    : {yyStart (set);    RETURN SymLBrace    ;}
  301. #rules#        "#"    : {RETURN SymNrSign    ;}
  302. #rules#        "/"    : {RETURN SymSlash    ;}
  303. #rules#        "<"    : {RETURN SymLess    ;}
  304. #rules#        ">"    : {RETURN SymGreater    ;}
  305. #rules#        ":"    : {PrevState := rules; yyStart (targetcode); RETURN SymColon;}
  306. #rules#        ":-"    : {PrevState := rules; yyStart (targetcode); RETURN SymColonMinus;}
  307.  
  308. #STD, set, rules# \\ n    : {Attribute.Ch := 012C; RETURN SymChar;}
  309. #STD, set, rules# \\ t    : {Attribute.Ch := 011C; RETURN SymChar;}
  310. #STD, set, rules# \\ v    : {Attribute.Ch := 013C; RETURN SymChar;}
  311. #STD, set, rules# \\ b    : {Attribute.Ch := 010C; RETURN SymChar;}
  312. #STD, set, rules# \\ r    : {Attribute.Ch := 015C; RETURN SymChar;}
  313. #STD, set, rules# \\ f    : {Attribute.Ch := 014C; RETURN SymChar;}
  314.  
  315. #STD, set, rules# \\ digit + : {
  316.                GetWord (Word);
  317.                SubString (Word, 2, Length (Word), TargetCode);
  318.                Attribute.Ch := CHR (CARDINAL (StringToInt (TargetCode)));
  319.                  RETURN SymChar;
  320.             }
  321.  
  322. #STD, set, rules# \\ ANY : {
  323.                GetWord (Word);
  324.                Attribute.Ch := Char (Word, 2);
  325.                  RETURN SymChar;
  326.             }
  327.  
  328. #STD, set, rules# - {\t\n\ \f\r} : {
  329.                GetWord (Word);
  330.                Attribute.Ch := Char (Word, 1);
  331.                  RETURN SymChar;
  332.             }
  333.  
  334. \f            :- {}
  335. \r            :- {}
  336.